import { ref, reactive, computed, watch } from 'vue'
import { defineStore } from 'pinia'
import {
  queryUserIsLogin,
  updateUserIsLogin,
  getChatRecordsByRoomId,
  insertChatRecords,
  insertChatRecord,
  updateMessageStatus,
  updateMessageDataUrl
} from '@/utils/Electron'
import { allChatRecords, requestMessage, uploadFile } from '@/lib/api'
import type { ChatRecordType } from '@/lib/interfaces'
import useAuthStore from './authStore'
import PubSub from 'pubsub-js'
import moment from 'moment'
import useRoomStore from './roomStore'
import useFriendStore from './friendStore'

export type ChatRecordStateType = {
  id: number
  recordList: Array<ChatRecordType>
}

export type currentChatRoomInfoType = {
  id: string
  roomName: string
  avatar: string
}

export default defineStore('chat', (store) => {
  // 引入其他Store
  const friendStore = useFriendStore()
  const roomStore = useRoomStore()
  // 定义属性
  const chatRecordList = ref<Array<ChatRecordStateType>>([]) // 聊天房间的聊天记录(聊天房间限制：根据用户屏幕显示的房间数量，聊天记录限制：20条)
  const loadingRecord = ref<Boolean>(false) //同步聊天记录的状态

  // 定义计算属性
  const currentChatRecords = computed(() => {
    const index = chatRecordList.value.findIndex(
      (item: any) => item.id == roomStore.currentChatRoomInfo.id
    )
    return index == -1 ? [] : chatRecordList.value[index].recordList
  })

  /**
  * 设置当前视窗之内的聊天房间房间以及聊天记录
  * @param list 当前视窗内出现的聊天房间
  */
  const setChatRecordList = (list: Array<any>): void => {
    if (list.length === 0) return
    // 移除掉视窗中已经消失的聊天房间(排除掉目前正在聊天的房间)
    chatRecordList.value.length > 0 &&
      chatRecordList.value.forEach((current, index) => {
        if (
          list.findIndex((item) => item.id === current.id) === -1 &&
          current.id.toString() !== roomStore.currentChatRoomInfo.id.toString()
        ) {
          // 如果当前新的房间里面没有这个房间，则移除掉这个房间
          chatRecordList.value.splice(index, 1)
        }
      })
    // 添加视窗中新出现的聊天房间的聊天记录
    list.forEach((current, index) => {
      if (list.findIndex((item) => item.id === current) === -1) {
        // 获取当前聊天房间的聊天记录
        getChatRecordsByRoomId(current, 0, 20).then((res: any) => {
          if (res.success) {
            const list = res.data.list.reverse();
            chatRecordList.value.push({
              id: current,
              recordList: list
            })
            // 给当前显示的聊天房间显示最新的聊天记录
            roomStore.setTheLatestMessageByRoomId(current)
          }
        })
      }
    })
  }

  /**
   * ##发送消息流程：
   * 1.向SQLite和Pina中添加一条正在发送中的文字消息并记录SQLite的ID
   * 2.调用发送消息的接口
   * 3.发送成功后更新Pina和SQLite中这条数据的发送状态并更新服务端的消息ID
   * ##非文字消息流程：
   * 1.向SQLite和Pina中添加一条正在发送中的图片消息（图片消息是base64或者本地路径）并记录SQLite的ID
   * 2.调用上传接口，将图片上传到服务器，并返回图片的地址
   * 3.替换Pina和SQLite中这条数据的图片地址
   * 4.上传成功后调用发送消息的接口
   * 5.发送成功后更新Pina和SQLite中这条数据的发送状态并更新服务端的消息ID
   * @param type 消息类型 0是文本消息 1是图片消息 2是语音消息 3是视频消息
   * @param msg 文本消息内容
   * @param imgs 图片数组
   * @param video  视频地址
   * @param volice // 语音地址
   * @returns
   */
  const sendMessage = async (type: number, msg: string, img: string, video: string, volice: string) => {
    const authStore = useAuthStore()
    const userInfo = authStore.userInfo
    // 保存到数据库中的数据默认都是正在发送中Loading中 -1 0 1
    const record = {
      id: 0,
      messageId: 0,
      roomId: roomStore.currentChatRoomInfo.id, // 房间ID
      sendUserId: userInfo.userId,
      sendName: userInfo.userName, // 发送人姓名!!
      avatar: userInfo.avatar,
      message: msg, // 文本消息
      refMessage: 0, // 消息引用
      status: 0,
      type: type, // 类型
      img: img.base64 ? img.base64 : '',
      video: video, // 视频地址
      volice: volice,
      time: moment().format('YYYY-MM-DD HH:mm:ss'),
      temp: type != 0 // 不是文本消息则临时保存
    } as ChatRecordType
    const recordObj = Object.assign({}, record, {id: 0})
    // 向本地数据库以及Pinia中更新最新消息
    const lastId = await sendMessageObj(record)
    currentChatRecords.value[currentChatRecords.value.length-1].id = lastId
    if(record.type == 0) {
        // 调用消息发送接口
        requestMessage(recordObj).then((res: any)=> {
          currentChatRecords.value[currentChatRecords.value.length-1].status = res.code == 0 ? 1 : -1
          updateMessageStatus({id: lastId, messageId: res.data.messageId, status: res.code == 0 ? 1 : -1})
        }).catch(()=> {
          currentChatRecords.value[currentChatRecords.value.length-1].status = -1
          updateMessageStatus({id: lastId, messageId: 0, status: -1})
        })
    } else if(record.type == 1) {
      // 给上一个消息设置SQLiteID
      // 调用图片上传接口
      uploadFile(img.file).then((imgRes: any)=> {
        // 修改Pinia中的图片地址
        currentChatRecords.value.forEach((item) => {
          if(item.id == lastId) {
            item.img = imgRes.url
          }
        })
        // 修改SQLite中的图片地址
        updateMessageDataUrl({id: lastId, img: imgRes.url})
        requestMessage(recordObj).then((res: any)=> {
          // 消息发送成功
          currentChatRecords.value[currentChatRecords.value.length-1].status = res.code == 0 ? 1 : -1
          updateMessageStatus({id: lastId, messageId: res.data.messageId, status: res.code == 0 ? 1 : -1})
        }).catch(()=> {
          currentChatRecords.value[currentChatRecords.value.length-1].status = -1
          updateMessageStatus({id: lastId, messageId: 0, status: -1})
        })
      }).catch(()=> {
        currentChatRecords.value[currentChatRecords.value.length-1].status = -1
        updateMessageStatus({id: lastId, messageId: 0, status: -1})
      })
    }
  }

  /**
   * 向本地数据库以及Pinia中更新最新消息
   * @param messageObj 消息对象
   */
  const sendMessageObj = async (messageObj: any, roomId = roomStore.currentChatRoomInfo.id) => {
    return new Promise((resolve, reject) => {
        // 保存数据到数据库
        insertChatRecord(messageObj).then((res) => {
          resolve(res)
          // 保存新消息到pinia中
          const index = chatRecordList.value.findIndex((item) => item.id == roomId)
          if(index>-1) {
            chatRecordList.value[index].recordList.push(messageObj)
            // 发布消息滚动到聊天记录下方
            PubSub.publish('scrollBottom', {})
            // 更新左侧最新消息
            roomStore.setTheLatestMessageByRoomId(messageObj.roomId)
          }
        })
    })
  }

  /**
   * 设置房间未读消息数量
   * @param roomId 
   * @param count 
   */
  // const setRoomNoReadCount = (roomId: string) => {
  //   // 修改本地数据库的数量
  //   updateChatNoMessage(roomId, roomId == currentChatRoomInfo.value.id)
  //   commentList.value.forEach((item: any) => {
  //     if (item.roomId == roomId) {
  //       item.noMessage = (roomId == currentChatRoomInfo.value.id ? 0 : item.noMessage+1)
  //     }
  //   })
  // }

  // 获取当前用户是否同步过数据
  const initChatData = () => {
    const authStore = useAuthStore()
    const userInfo = authStore.userInfo
    queryUserIsLogin(userInfo.userId).then((res: any) => {
      // 如果当前用户已经同步过数据,就从本地获取聊天房间
      if (res.data.loginCount > 0) {
        roomStore.getLocalChatRooms(userInfo)
        friendStore.getLocalFriendsRelation() // 获取本地好友关系
        friendStore.getLocalFriendsRequests() // 获取本地好友请求
      } else {
        // 当前用户没有同步过数据,则从服务端同步用户聊天数据
        loadingRecord.value = true
        const req1 = roomStore.getRemoteChatRooms(true)
        const req2 = getRemoteChatRecords()
        const req3 = friendStore.getRemoteFriendsRelation()
        const req4 = friendStore.getRemoteFriendsRequests()
        // 请求处理完成之后设置第一个聊天房间的前20条聊天数据
        Promise.all([req1, req2, req3, req4]).then(() => {
          loadingRecord.value = false
          updateUserIsLogin(userInfo.userId)
        })
      }
    })
  }

  // 获取本地的聊天房间
  // const getLocalChatRooms = (userInfo: any) => {
  //   queryChatRooms(userInfo.userId).then((res: any) => {
  //     // 将聊天数据放入Pinia中
  //     if (res.data.list || res.data.list.length > 0) {
  //       const firstChatRoom = res.data.list[0]
  //       // 注入聊天房间
  //       setCommentList(
  //         res.data.list.map((item: any) => ({
  //           ...item,
  //           id: item.roomId,
  //           lastMessage: item.lastMessage || {}
  //         }))
  //       )
  //       if(firstChatRoom) {
  //         // 注入当前聊天房间信息
  //         setCurrentChattingRoomInfo({
  //           id: firstChatRoom.roomId,
  //           roomName: firstChatRoom.name,
  //           avatar: firstChatRoom.avatar
  //         })
  //       }
  //     }
  //   })
  // }

  // 同步服务端所有的聊天房间
  // const getRemoteChatRooms = (insert = false) => {
  //   const userInfo = JSON.parse(getUserInfo())
  //   return chatRoomList().then((res: any) => {
  //     if (res.code === 0) {
  //       const firstChatRoom = res.data.list[0]
  //       // chatStore.stateSync()
  //       // 注入Pinia聊天房间数据
  //       setCommentList(
  //         res.data.list.map((item: any) => ({
  //           ...item,
  //           roomId: item.id,
  //           lastMessage: ''
  //         }))
  //       )
  //       if(firstChatRoom) {
  //         // 注入聊天房间的聊天数据
  //         setCurrentChattingRoomInfo({
  //           id: firstChatRoom.id,
  //           roomName: firstChatRoom.name,
  //           avatar: firstChatRoom.avatar
  //         })
  //       }
  //       if (insert && res.data.list.length > 0) {
  //         // 将房间插入本地数据库
  //         insertChatRooms(
  //           res.data.list.map((item: any) => ({
  //             ...item,
  //             username: userInfo.userName,
  //             lastMessage: JSON.stringify(item.lastMessage || {})
  //           })),
  //           userInfo.userId
  //         )
  //       }
  //     }
  //   })
  // }

  /**
   * 插入新房间
   * @param roomId 
   */
  // const addChatRoomWithMessage = (roomInfo: any, message: any) => {
  //   // 默认消息是发送成功了的
  //   Object.assign(message, { status: 1 })
  //   const userInfo = JSON.parse(getUserInfo())
  //   const list = [roomInfo]
  //   // 把新房间插入到SQLlite中
  //   insertChatRooms(
  //     list.map((item: any) => ({
  //       ...item,
  //       name: userInfo.userName,
  //       lastMessage: JSON.stringify(item.lastMessage || {}),
  //       noMessage: 1
  //     })),
  //     userInfo.userId
  //   )
  //   // 将新房间放到Pinia中并且是第一位
  //   Object.assign(roomInfo, {roomId: roomInfo.id,lastMessage: "", noMessage: 1})
  //   commentList.value.unshift(roomInfo)
  //   // 将聊天数据放入SQLite
  //   Object.assign(message, {time: moment().format('YYYY-MM-DD HH:mm:ss')})
  //   insertChatRecord(message)
  //   // 将聊天数据放入Pinia中
  //   const index = chatRecordList.value.findIndex(
  //     (item) => item.id === roomInfo.id
  //   )
  //   if(index==-1) {
  //     chatRecordList.value.push({
  //       id: roomInfo.id,
  //       recordList: [message]
  //     })
  //   } else {
  //     chatRecordList.value[index].recordList.push(message)
  //   }
  // }

  // 同步服务端所有的聊天记录
  const getRemoteChatRecords = () => {
    const authStore = useAuthStore()
    const userInfo = authStore.userInfo
    return allChatRecords(userInfo.userId).then((res: any) => {
      if (res.code === 0 && res.data.list.length > 0) {
        insertChatRecords(res.data.list)
      }
    })
  }

  // 获取服务端好友请求信息
  // const getRemoteFriendsRequests = () => {
  //   return allFriendsRequests().then((res: any) => {
  //     if (res.code === 0 && res.data.list.length > 0) {
  //       insertFriendsRequests(res.data.list)
  //       setFriendsRequests(res.data.list)
  //     }
  //   })
  // }

  // 获取本地好友请求信息
  // const getLocalFriendsRequests = () => {
  //   const userInfo = JSON.parse(getUserInfo())
  //   queryFriendRequests(userInfo.userId).then((res: any) => {
  //     // 将聊天数据放入Pinia中
  //     if (res.data.list || res.data.list.length > 0) {
  //       setFriendsRequests(res.data.list)
  //     }
  //   })
  // }

  // 获取服务端好友信息
  // const getRemoteFriendsRelation = () => {
  //   return friendsRelationShip().then((res: any) => {
  //     if (res.code === 0 && res.data.list.length > 0) {
  //       insertFriendsRelationShip(res.data.list)
  //       setFriendsRelation(res.data.list)
  //     }
  //   })
  // }

  // 获取服务端好友信息
  // const getLocalFriendsRelation = () => {
  //   const userInfo = JSON.parse(getUserInfo())
  //   queryFriendRelation(userInfo.userId).then((res: any) => {
  //     // 将聊天数据放入Pinia中
  //     if (res.data.list || res.data.list.length > 0) {
  //       setFriendsRelation(res.data.list)
  //     }
  //   })
  // }

  // 设置当前用户的好友列表
  // const setFriendsRelation = (list: any) => {
  //   friendsRelation.value = list.map((item: any) => ({
  //     id: item.id,
  //     relationId: item.relationId,
  //     avatar: item.avatar,
  //     loginName: item.loginName,
  //     username: item.userName || item.username
  //   }))
  // }

  // const addFriendsRelation = (obj: any) => {
  //   insertFriendsRelationShip([obj])
  //   friendsRelation.value.unshift({
  //     avatar: obj.avatar,
  //     id: obj.relationId,
  //     loginName: obj.loginName,
  //     relationId: obj.id,
  //     username: obj.userName
  //   })
  // }

  // 设置当前用户的好友请求列表
  // const setFriendsRequests = (list: any) => {
  //   friendsRequests.value = list.map((item: any) => ({
  //     id: item.id,
  //     requestId: item.requestId,
  //     requesterId: item.requesterId,
  //     receiverId: item.receiverId,
  //     createTime: item.createTime,
  //     status: item.status,
  //     requestMessage: item.requestMessage,
  //     requestUserName: item.requestUserName,
  //     requestAvatar: item.requestAvatar,
  //   }))
  // }

  const resetStore = () => {
    // setFriendsRelation([])
    // setFriendsRequests([])
    // currentChatRoomInfo.value =({ id: '0', roomName: '', avatar: '' })
    chatRecordList.value = []
    // commentList.value = []
    loadingRecord.value = false
  }

  return {
    // friendsRequests,
    // commentList,
    // currentChatRoomInfo,
    chatRecordList,
    currentChatRecords,
    loadingRecord,
    // friendsRelation,
    // friendsRelationComputed,
    sendMessageObj,
    // setCurrentChattingRoomInfo,
    setChatRecordList,
    // setTheLatestMessageByRoomId,
    sendMessage,
    // setCommentList,
    // addChatRoomWithMessage,
    // addFriendsRelation,
    initChatData,
    // setRoomNoReadCount,
    resetStore
  }
})
